{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> Using MOMENT for Forecasting </h1>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "### 1. A Quick Introduction to Forecasting\n",
    "### 2. Loading MOMENT\n",
    "### 3. Inputs and Outputs\n",
    "### 4. Training the Forecasting Head"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. A Quick Introduction to Forecasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time series forecasting is another popular modeling task that involves predicting future values of a time series based on its historical patterns. For instance, in the context of stock market data, forecasting aims to estimate the future stock prices by analyzing past price movements and other relevant factors. In this tutorial, we will explore how to use MOMENT to tackle the time series forecasting in linearly probed setting. Mathematically, the time series forecasting problem can be defined as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem**: Given a time-series $T = [x_1, ..., x_L], \\ x_i \\in \\mathbb{R}^{C}$ of length $L$ with $C$ channels (sensors or variables), the forecasting problem is to predict the next $H$ time-steps $[x_{L+1}, \\dots, x_{L+H}]$. Depending on the length of the horizon, forecasting can be categorized as short or long-horizon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Loading MOMENT\n",
    "\n",
    "We will first install the MOMENT package, load some essential packages and the pre-trained model.\n",
    "\n",
    "MOMENT can be loaded in 4 modes: (1) `reconstruction`, (2) `embedding`, (3) `forecasting`, and (4) `classification`.\n",
    "\n",
    "In the `reconstruction` mode, MOMENT reconstructs input time series, potentially containing missing values. We can solve imputation and anomaly detection problems in this mode. This mode is suitable for solving imputation and anomaly detection tasks. During pre-training, MOMENT is trained to predict the missing values within uniformly randomly masked patches (disjoint sub-sequences) of the input time series, leveraging information from observed data in other patches. As a result, MOMENT comes equipped with a pre-trained reconstruction head, enabling it to address imputation and anomaly detection challenges in a zero-shot manner! Check out the `anomaly_detection.ipynb` and `imputation.ipynb` notebooks for more details!\n",
    "\n",
    "In the `embedding model`, MOMENT learns a $d$-dimensional embedding (e.g., $d=1024$ for `MOMENT-1-large`) for each input time series. These embeddings can be used for clustering and classification. MOMENT can learn embeddings in a zero-shot setting! Check out `representation_learning.ipynb` notebook for more details!\n",
    "\n",
    "The `forecasting` and `classification` modes are used for forecasting and classification tasks, respectively. In these modes, MOMENT learns representations which are subsequently mapped to the forecast horizon or the number of classes, using linear forecasting and classification heads. Both the forecasting and classification head are randomly initialized, and therefore must be fine-tuned before use. Check out the `forecasting.ipynb` notebook for more details!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install numpy pandas matplotlib tqdm\n",
    "# !pip install git+https://github.com/moment-timeseries-foundation-model/moment.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from momentfm import MOMENTPipeline\n",
    "\n",
    "model = MOMENTPipeline.from_pretrained(\n",
    "    \"AutonLab/MOMENT-1-large\", \n",
    "    model_kwargs={\n",
    "        'task_name': 'forecasting',\n",
    "        'forecast_horizon': 192,\n",
    "        'head_dropout': 0.1,\n",
    "        'weight_decay': 0,\n",
    "        'freeze_encoder': True, # Freeze the patch embedding layer\n",
    "        'freeze_embedder': True, # Freeze the transformer encoder\n",
    "        'freeze_head': False, # The linear forecasting head must be trained\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MOMENTPipeline(\n",
      "  (normalizer): RevIN()\n",
      "  (tokenizer): Patching()\n",
      "  (patch_embedding): PatchEmbedding(\n",
      "    (value_embedding): Linear(in_features=8, out_features=1024, bias=False)\n",
      "    (position_embedding): PositionalEmbedding()\n",
      "    (dropout): Dropout(p=0.1, inplace=False)\n",
      "  )\n",
      "  (encoder): T5Stack(\n",
      "    (embed_tokens): Embedding(32128, 1024)\n",
      "    (block): ModuleList(\n",
      "      (0): T5Block(\n",
      "        (layer): ModuleList(\n",
      "          (0): T5LayerSelfAttention(\n",
      "            (SelfAttention): T5Attention(\n",
      "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (relative_attention_bias): Embedding(32, 16)\n",
      "            )\n",
      "            (layer_norm): T5LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "          (1): T5LayerFF(\n",
      "            (DenseReluDense): T5DenseGatedActDense(\n",
      "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
      "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
      "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
      "              (dropout): Dropout(p=0.1, inplace=False)\n",
      "              (act): NewGELUActivation()\n",
      "            )\n",
      "            (layer_norm): T5LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "      (1-23): 23 x T5Block(\n",
      "        (layer): ModuleList(\n",
      "          (0): T5LayerSelfAttention(\n",
      "            (SelfAttention): T5Attention(\n",
      "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "            )\n",
      "            (layer_norm): T5LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "          (1): T5LayerFF(\n",
      "            (DenseReluDense): T5DenseGatedActDense(\n",
      "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
      "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
      "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
      "              (dropout): Dropout(p=0.1, inplace=False)\n",
      "              (act): NewGELUActivation()\n",
      "            )\n",
      "            (layer_norm): T5LayerNorm()\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (final_layer_norm): T5LayerNorm()\n",
      "    (dropout): Dropout(p=0.1, inplace=False)\n",
      "  )\n",
      "  (head): ForecastingHead(\n",
      "    (flatten): Flatten(start_dim=-2, end_dim=-1)\n",
      "    (dropout): Dropout(p=0.1, inplace=False)\n",
      "    (linear): Linear(in_features=65536, out_features=192, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "model.init()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unfrozen parameters:\n",
      "     head.linear.weight\n",
      "     head.linear.bias\n"
     ]
    }
   ],
   "source": [
    "print(\"Unfrozen parameters:\")\n",
    "for name, param in model.named_parameters():    \n",
    "    if param.requires_grad:\n",
    "        print('    ', name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Inputs and Outputs\n",
    "\n",
    "Let's begin by performing a forward pass through MOMENT and examining its outputs!\n",
    "\n",
    "MOMENT takes 3 inputs:\n",
    "\n",
    "1. An input time series of length $T = 512$ timesteps and $C$ channels, and\n",
    "2. Two optional masks, both of length $T = 512$.\n",
    "    - The input mask is utilized to regulate the time steps or patches that the model should attend to. For instance, in the case of shorter time series, you may opt not to attend to padding. To implement this, you can provide an input mask with zeros in the padded locations.\n",
    "    - The second mask, referred to simply as mask, denotes masked or unobserved values. We employ mask tokens to replace all patches containing any masked time step (for further details, refer to Section 3.2 in our paper). MOMENT can attend to these mask tokens during reconstruction.\n",
    "    - By default, all time steps are observed and attended to.\n",
    "\n",
    "MOMENT returns a `TimeseriesOutputs` object. Since this is a forecasting task, it returns a `forecast` of the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TimeseriesOutputs(forecast=tensor([[[-0.0428, -0.0127, -0.0482,  ..., -0.0033,  0.0507, -0.0339]],\n",
      "\n",
      "        [[-0.0998, -0.1037, -0.1361,  ..., -0.2185, -0.0607, -0.1519]],\n",
      "\n",
      "        [[-0.0847, -0.0434, -0.0255,  ..., -0.0740, -0.0775, -0.0049]],\n",
      "\n",
      "        ...,\n",
      "\n",
      "        [[-0.0559, -0.0596, -0.0881,  ..., -0.0409,  0.0090, -0.0554]],\n",
      "\n",
      "        [[-0.0045, -0.1016, -0.1286,  ..., -0.0135, -0.0256,  0.0052]],\n",
      "\n",
      "        [[-0.0324, -0.0062,  0.0015,  ...,  0.0194,  0.1688, -0.0190]]],\n",
      "       grad_fn=<AddBackward0>),\n",
      "                  anomaly_scores=None,\n",
      "                  logits=None,\n",
      "                  labels=None,\n",
      "                  input_mask=tensor([[1., 1., 1.,  ..., 1., 1., 1.],\n",
      "        [1., 1., 1.,  ..., 1., 1., 1.],\n",
      "        [1., 1., 1.,  ..., 1., 1., 1.],\n",
      "        ...,\n",
      "        [1., 1., 1.,  ..., 1., 1., 1.],\n",
      "        [1., 1., 1.,  ..., 1., 1., 1.],\n",
      "        [1., 1., 1.,  ..., 1., 1., 1.]]),\n",
      "                  pretrain_mask=None,\n",
      "                  reconstruction=None,\n",
      "                  embeddings=None,\n",
      "                  metadata=None,\n",
      "                  illegal_output=False)\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "import torch\n",
    "\n",
    "# takes in tensor of shape [batchsize, n_channels, context_length]\n",
    "x = torch.randn(16, 1, 512)\n",
    "output = model(x)\n",
    "pprint(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Training the Forecasting Head"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MOMENT is pre-trained using a reconstruction head and a reconstruction head. To use MOMENT for forecasting, we replace the reconstruction head to a forecasting head. The forecasting head is a randomly initilized linear layer which maps MOMENT's embeddings to the forecasting horizon. \n",
    "\n",
    "**The forecasting head is randomly initialized, so it must be trained on your data.**\n",
    "\n",
    "Below, we show a quick example of how we can train the forecasting head. In these experiments, we will use Hourly Electricity Transformer Temperature (ETTh1) dataset introduced by [Zhou et al., 2020](https://arxiv.org/abs/2012.07436). Check out [ETDataset](https://github.com/zhouhaoyi/ETDataset) for more information! This dataset is widely use to benchmark long-horizon forecasting models. \n",
    "\n",
    "In this experiment, MOMENT will take multi-variate time series as input, and predict the next 192 time steps, i.e. the forecast horizon is set to 192. We will fine-tune the model using Mean Squarred Error (MSE), and report both MSE and the Mean Absolute Error (MAE) of the fine-tuned model. Since MOMENT is already pre-trained on millions of time series, we only need to fine-tune it for 1 epoch!\n",
    "\n",
    "We implemented a simple forecasting dataset class in `moment.data.informer_dataset`. `moment.utils.forecasting_metrics` contains implementations for MSE and MAE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Model Finetuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 993/993 [04:32<00:00,  3.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: Train loss: 0.467\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 337/337 [01:26<00:00,  3.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: Test MSE: 0.422 | Test MAE: 0.432\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.cuda.amp\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.optim.lr_scheduler import OneCycleLR\n",
    "from tqdm import tqdm\n",
    "\n",
    "from momentfm.utils.utils import control_randomness\n",
    "from momentfm.data.informer_dataset import InformerDataset\n",
    "from momentfm.utils.forecasting_metrics import get_forecasting_metrics\n",
    "\n",
    "# Set random seeds for PyTorch, Numpy etc.\n",
    "control_randomness(seed=13) \n",
    "\n",
    "# Load data\n",
    "train_dataset = InformerDataset(data_split=\"train\", random_seed=13, forecast_horizon=192)\n",
    "train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)\n",
    "\n",
    "test_dataset = InformerDataset(data_split=\"test\", random_seed=13, forecast_horizon=192)\n",
    "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=True)\n",
    "\n",
    "criterion = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "cur_epoch = 0\n",
    "max_epoch = 1\n",
    "\n",
    "# Move the model to the GPU\n",
    "model = model.to(device)\n",
    "\n",
    "# Move the loss function to the GPU\n",
    "criterion = criterion.to(device)\n",
    "\n",
    "# Enable mixed precision training\n",
    "scaler = torch.cuda.amp.GradScaler()\n",
    "\n",
    "# Create a OneCycleLR scheduler\n",
    "max_lr = 1e-4\n",
    "total_steps = len(train_loader) * max_epoch\n",
    "scheduler = OneCycleLR(optimizer, max_lr=max_lr, total_steps=total_steps, pct_start=0.3)\n",
    "\n",
    "# Gradient clipping value\n",
    "max_norm = 5.0\n",
    "\n",
    "while cur_epoch < max_epoch:\n",
    "    losses = []\n",
    "    for timeseries, forecast, input_mask in tqdm(train_loader, total=len(train_loader)):\n",
    "        # Move the data to the GPU\n",
    "        timeseries = timeseries.float().to(device)\n",
    "        input_mask = input_mask.to(device)\n",
    "        forecast = forecast.float().to(device)\n",
    "\n",
    "        with torch.cuda.amp.autocast():\n",
    "            output = model(timeseries, input_mask)\n",
    "        \n",
    "        loss = criterion(output.forecast, forecast)\n",
    "\n",
    "        # Scales the loss for mixed precision training\n",
    "        scaler.scale(loss).backward()\n",
    "\n",
    "        # Clip gradients\n",
    "        scaler.unscale_(optimizer)\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)\n",
    "\n",
    "        scaler.step(optimizer)\n",
    "        scaler.update()\n",
    "        optimizer.zero_grad(set_to_none=True)\n",
    "\n",
    "        losses.append(loss.item())\n",
    "\n",
    "    losses = np.array(losses)\n",
    "    average_loss = np.average(losses)\n",
    "    print(f\"Epoch {cur_epoch}: Train loss: {average_loss:.3f}\")\n",
    "\n",
    "    # Step the learning rate scheduler\n",
    "    scheduler.step()\n",
    "    cur_epoch += 1\n",
    "    \n",
    "    # Evaluate the model on the test split\n",
    "    trues, preds, histories, losses = [], [], [], []\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for timeseries, forecast, input_mask in tqdm(test_loader, total=len(test_loader)):\n",
    "        # Move the data to the GPU\n",
    "            timeseries = timeseries.float().to(device)\n",
    "            input_mask = input_mask.to(device)\n",
    "            forecast = forecast.float().to(device)\n",
    "\n",
    "            with torch.cuda.amp.autocast():\n",
    "                output = model(timeseries, input_mask)\n",
    "            \n",
    "            loss = criterion(output.forecast, forecast)                \n",
    "            losses.append(loss.item())\n",
    "\n",
    "            trues.append(forecast.detach().cpu().numpy())\n",
    "            preds.append(output.forecast.detach().cpu().numpy())\n",
    "            histories.append(timeseries.detach().cpu().numpy())\n",
    "    \n",
    "    losses = np.array(losses)\n",
    "    average_loss = np.average(losses)\n",
    "    model.train()\n",
    "\n",
    "    trues = np.concatenate(trues, axis=0)\n",
    "    preds = np.concatenate(preds, axis=0)\n",
    "    histories = np.concatenate(histories, axis=0)\n",
    "    \n",
    "    metrics = get_forecasting_metrics(y=trues, y_hat=preds, reduction='mean')\n",
    "\n",
    "    print(f\"Epoch {cur_epoch}: Test MSE: {metrics.mse:.3f} | Test MAE: {metrics.mae:.3f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Visualization\n",
    "\n",
    "Next, let's visualize the forecasts for a sample from the ETTh1 dataset and compare it with the ground truth forecast for the given time series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Assuming histories, trues, and preds are your lists containing the data\n",
    "# Extracting the first data point\n",
    "\n",
    "channel_idx = np.random.randint(0, 7) # There are 7 channels in this dataset\n",
    "time_index = np.random.randint(0, trues.shape[0]) \n",
    "\n",
    "history = histories[time_index, channel_idx, :] \n",
    "true = trues[time_index, channel_idx, :]\n",
    "pred = preds[time_index, channel_idx, :]\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "\n",
    "# Plotting the first time series from history\n",
    "plt.plot(range(len(history)), history, label='History (512 timesteps)', c='darkblue')\n",
    "\n",
    "# Plotting ground truth and prediction\n",
    "num_forecasts = len(true)\n",
    "\n",
    "offset = len(history)\n",
    "plt.plot(range(offset, offset + len(true)), true, label='Ground Truth (192 timesteps)', color='darkblue', linestyle='--', alpha=0.5)\n",
    "plt.plot(range(offset, offset + len(pred)), pred, label='Forecast (192 timesteps)', color='red', linestyle='--')\n",
    "\n",
    "plt.title(f\"ETTh1 (Hourly) -- (idx={time_index}, channel={channel_idx})\", fontsize=18)\n",
    "plt.xlabel('Time', fontsize=14)\n",
    "plt.ylabel('Value', fontsize=14)\n",
    "plt.legend(fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Results Interpretation: MOMENT Performs Well for Forecasting in Limited Supervision Settings\n",
    "\n",
    "Here, we can see that MOMENT **trained for 1 epoch only, without any hyperparameter tuning**, can forecast time series well! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
